/**
 *
 */
package com.doudoukeji.service.Activity.splash;

import android.content.Context;
import android.util.Log;

import com.doudoukeji.service.Activity.ConstantValue;
import com.doudoukeji.service.Bean.AppVersion;
import com.doudoukeji.service.Bean.HospitalLitapal;
import com.doudoukeji.service.Bean.ServiceLitapal;
import com.doudoukeji.service.Bean.Token;
import com.doudoukeji.service.Http.MyHttpResponseHandler;
import com.doudoukeji.service.Utils.ABAppUtil;
import com.doudoukeji.service.Utils.LogUtil;
import com.doudoukeji.service.Utils.SharedPreferencesUtils;
import com.loopj.android.http.RequestParams;
import com.sanhai.android.mvp.BasePresenter;
import com.sanhai.android.service.http.BusinessClient;
import com.sanhai.android.service.http.Response;

import org.apache.commons.lang3.StringUtils;
import org.apache.http.Header;
import org.litepal.crud.DataSupport;

import java.util.List;
import java.util.Map;

/**
 * @version 2.0
 * @类描述： 起始页
 * @项目名称：douDouTech
 * @类名称： SplashActivity
 * @包名称： com.doudoukeji.service.Activity.splash
 * @创建人：张强 boy
 * @创建时间：2016/3/7 16:40
 * @修改人：
 * @修改时间：2016/3/7 16:40
 * @修改备注： new parent class(用一句话描述修改了什么)
 */
public class SplashPresenter extends BasePresenter {

    private SplashView view = null;
    private static final String TAG = "LaunchActivity";
    private Context mcontext;

    //是否登录
    private boolean isLogin = false;
    //医院服务信息是否填完整
    private boolean isAll = false;
    //是否更新
    private boolean isUpdata = false;
    //是否显示数据同步进度条
    private boolean isShow = false;
    //同步数据失败
    private boolean isErrar = false;

    private AppVersion appVersionBean = null;

    public SplashPresenter(Context context, SplashView view) {
        super(context, view);
        this.view = view;
        this.mcontext = context;
    }

    /**
     * @param
     */
    public void launch() {
//        version	String	是	APP版本号（服务端起始字段为，端起始字段为，后端判断传来本字段，端版本号低，则返回信息，如一致则不返回信息）
//        device	String	是	设备类型
//        hosVersion	String	是	医院数据的版本号（服务端起始字段为，端起始字段为，后端判断传来本字段，端版本号低，则返回信息，如一致则不返回信息）
//        servVersion	String	是	服务项目的版本号（服务端起始字段为，端起始字段为，后端判断传来本字段，端版本号低，则返回信息，如一致则不返回信息）
//        phone	String	否	用户手机号
//        userId	String 	否	用户（用户手机号与用户都一致，则返回用户信息）
        final RequestParams params = new RequestParams();
        params.put("version", ABAppUtil.getAppVersion(mcontext));
        params.put("device", "1");
        params.put("hosVersion", Token.getHosVersion());
        params.put("servVersion", Token.getServVersion());
        params.put("phone", Token.getPhone());
        params.put("userId", Token.getId());


        BusinessClient.post(ConstantValue.splashUrl, params, new MyHttpResponseHandler() {

            @Override
            public void onStart() {
                super.onStart();
                String isFirst = SharedPreferencesUtils.getParam(mcontext, "isFirst", "-1");
                if (!isFirst.equals("0")) {
                    view.ShowSynchronousData();
                    isShow = true;
                }
            }

            @Override
            public void onMyResponse(Response response) {
                LogUtil.info(SplashPresenter.class, "启动的返回数据:" + response.getJson(),
                        ConstantValue.currentStage);

                if (!response.isSucceed()) {
                    Log.i("CheckVersion", "检查新版本失败");
                    return;
                }
                //app更新版本号
                String appVersion = response.getString("appVersion");
                if (StringUtils.isBlank(appVersion)) {
                    appVersion = "0";
                }
                // "hosVersion": 1,//医院列表最新版本号
                String hosVersion = response.getString("hosVersion");
                if (StringUtils.isBlank(hosVersion)) {
                    hosVersion = "0";
                    SharedPreferencesUtils.setParam(mcontext, "hosVersion", appVersion);
                } else {
                    SharedPreferencesUtils.setParam(mcontext, "hosVersion", appVersion);
                }
                // "servVersion": 1,//服务项目最新版本号
                String servVersion = response.getString("servVersion");
                if (StringUtils.isBlank(servVersion)) {
                    servVersion = "0";
                    SharedPreferencesUtils.setParam(mcontext, "servVersion", appVersion);
                } else {
                    SharedPreferencesUtils.setParam(mcontext, "servVersion", appVersion);
                }
                // "userVersion": 1,//0-不登录自动登录
                String userVersion = response.getString("userVersion");
                if (StringUtils.isBlank(userVersion)) {
                    userVersion = "0";
                }

                Map<String, Object> data = response.getData();

                //版本信息表
                Map<String, Object> appData = response.getMap("appData");
                //存数据库的医院信息
                List<Map<String, String>> hosData = response.getListData("hosData");
                //存数据库的医院信息
                List<Map<String, String>> servData = response.getListData("servData");
                //存入文件的用户信息
                Map<String, Object> userInfo = response.getMap("userInfo");

                //第一次进入显示数据同步信息 ，设置标记为0标示已经登录过了
                //第二次进入有同步数据时打开同步服务器，直接进入主页
                //如果有数据字典产生，则显示数据同步
                if (!Token.getHosVersion().equals(hosVersion)) {
                    //存入数据库的数据列表   数据字典
                    setHospitalLitapal(hosData);
                }

                if (!Token.getServVersion().equals(servVersion)) {
                    //存入数据库的数据列表   数据字典
                    setServcieLitapal(servData);
                }

                if ("1".equals(userVersion)) {
                    setUserInfoData(userInfo);
                }


                //版本判断，是否要更新版本
                int NativeappVersion = ABAppUtil.getAppVersion(Token.getMcontext());

                if ((NativeappVersion + "").compareTo(appVersion) < 0) {
                    isUpdata = true;
                    appVersionBean = new AppVersion();

                    ///  "versionNo": "4",//最新版本号
                    //        "versionName": "第四版最新版本名称
                    //        "descr": 描述版本描述
                    //    "device": "1",//返回设备信息
                    //            "forceUpdate": "0",//是否强制更新
                    //            "path": 路径更新路径
                    appVersionBean.setVersionNo((String) appData.get("versionNo"));
                    appVersionBean.setVersionName((String) appData.get("versionName")); // 0表示非必须，1表示必须
                    appVersionBean.setDescr((String) appData.get("descr"));
                    appVersionBean.setDevice((String) appData.get("device"));
                    appVersionBean.setForceUpdate((String) appData.get("forceUpdate"));
                    appVersionBean.setPath((String) appData.get("path"));
                    return;
                }
            }

            @Override
            public void onFinish() {
                super.onFinish();
                if (!isUpdata) {
                    String isFirst = SharedPreferencesUtils.getParam(mcontext, "isFirst", "0");
                    //第一次登录过则标记为1，跳过引导页到主界面或者登录页
                    if ("1".equals(isFirst)) {
                        if (!isErrar) {
                            if (StringUtils.isNotBlank(Token.getHospitals()) && StringUtils.isNotBlank(Token.getServices())) {
                                String hosAndSer = SharedPreferencesUtils.getParam(mcontext, "HosAndSer", "1");
                                if ("1".equals(hosAndSer)){
                                    isAll = true;
                                }else{
                                    isAll = false;
                                }

                            } else {
                                isAll = false;
                            }

                            if (isShow) {
                                view.DissSynchronousData();
                            }

                            if (isLogin) {
                                if (isAll) {
                                    if ("1".equals(SharedPreferencesUtils.getParam(mcontext, "READ", "0"))) {
                                        view.intentMainActivity();
                                    } else {
                                        view.initentDisclaimerActivity();
                                    }

                                } else {
                                    view.intentEditmessageActivity();
                                }
                            } else {
                                view.intentLoginActitity();
                            }
                        }

                    } else {
                        if (!isErrar) {
                            SharedPreferencesUtils.setParam(mcontext, "isFirst", "1");
//                            view.intentGuideActivity();
                            view.intentLoginActitity();
                            // 隐藏数据同步进度条
                            view.DissSynchronousData();
                        }
                    }
                } else {
                    view.tipUpdataDiolag(appVersionBean);
                }

            }

            @Override
            public void onFailure(int i, Header[] headers, byte[] bytes, Throwable throwable) {
                super.onFailure(i, headers, bytes, throwable);
                if (isShow) {
                    view.ErrorSynchronousData();
                    isErrar = true;
                }

            }
        });
    }

    /**
     * 设置登录信息
     */
    private void setUserInfoData(Map<String, Object> userInfo) {
        //        "id": "5",//用户
        //                "phone": "13963941179",//用户手机号
        //                "name": "工程新一用户名称
        //        "hospitals":”医院”医院青岛医院黄岛山大医院
        //        “services:”服务项目”服务项目挂号挂号
        //        "token": "afdsgjfkljgljeoirewl;gfdkasjkfj",//唯一识别码

        if (!isShow) {
            // 显示数据同步进度条
            view.ShowSynchronousData();
            isShow = true;
        }


        Token.setId((String) userInfo.get("id"));
        Token.setPhone((String) userInfo.get("phone"));
        Token.setName((String) userInfo.get("name"));
        Token.setHospitals((String) userInfo.get("hospitals"));
        Token.setServices((String) userInfo.get("services"));
        Token.setToken((String) userInfo.get("token"));

            isLogin = true;
    }

    /**
     * 存入数据库的数据列表   医院信息数据字典
     *
     * @param list
     */
    public void setHospitalLitapal(List<Map<String, String>> list) {

        if (!isShow) {
            // 显示数据同步进度条
            view.ShowSynchronousData();
            isShow = true;
        }


        if (list != null && list.size() > 0) {
            DataSupport.deleteAll(HospitalLitapal.class);
            for (Map<String, String> map : list) {
                HospitalLitapal dicf = new HospitalLitapal();
//                "id": "1",   //医院
//                        "name":"青岛市立医院医院名称
//                "areaName": "市南区所在城市
//                "areaId": "0110" //地区
                dicf.setCityid(map.get("id"));
                dicf.setName(map.get("name"));
                dicf.setAreaName(map.get("areaName"));
                dicf.setAreaId(map.get("areaId"));
                dicf.save();
            }
            LogUtil.info("医院DicInFor表有" + DataSupport.count(HospitalLitapal.class) + "条数据====",
                    ConstantValue.currentStage);
        }

    }


    /**
     * 存入数据库的数据列表   服务项目数据字典
     *
     * @param list
     */
    public void setServcieLitapal(List<Map<String, String>> list) {

        if (!isShow) {
            // 显示数据同步进度条
            view.ShowSynchronousData();
            isShow = true;
        }


        if (list != null && list.size() > 0) {
            DataSupport.deleteAll(ServiceLitapal.class);
            for (Map<String, String> map : list) {
                ServiceLitapal dicf = new ServiceLitapal();
                dicf.setServiceid(map.get("id"));
                dicf.setName(map.get("name"));
                dicf.setMemo(map.get("memo"));
                dicf.save();
            }
            LogUtil.info("服务DicInFor表有" + DataSupport.count(ServiceLitapal.class) + "条数据====",
                    ConstantValue.currentStage);
        }

    }


}